 /******************************************************************************
*   Universidad del Valle de Guatemala
*   Algoritmos y estructura de datos
*   Hoja de trabajo 6: Utilización de java collection framework
*   Samantha Catún				Carnet: 12382
*   Kevin Godínez                               Carnet: 12717	
*	
*   Nombre del script: Driver
*   Descripción: Driver que maneja todo respecto a la respuesta de las preguntas
*                planteadas: uniones e intersecciones de los conjuntos de desarro-
*                lladores de java, web o celulares.
******************************************************************************/ 
package hoja6;


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
public class Driver {

    
    public int intLista;
    public String strMensaje;
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //Se crea el objeto que leerá los nombres a ingresar por el usuario
        Scanner ingreso = new Scanner(System.in);
        //--------------------------------------------------------------------------------
        //en estas variables se guardaran el numero de programadores para cada categoría. 
        int njava=0, nweb=0, ncel=0; 
         //--------------------------------------------------------------------------------
        
         //--------------------------------------------------------------------------------
        //Variables que se utilizarán para la selección de *********
        char op = ' ';
        String opcion ="s";
         //--------------------------------------------------------------------------------
        String selector ="inicio"; //encargada del control de una de las opciones en el ingreso de programadores
        int implementacion=0; //encargada de determinar la implementacion seleccionada con factory
        
        //while (((cargoCodigo)==false)||(selPila== false) {
        /*Mientras no se ingrese un valor correcto, se mostrará el menú principal
         * hasta que lo haga.*/
        while (enteroAceptado (opcion,1,3)== false){
            op = ' ';
            //--------------------------------------------------------------------------------
            //Se muestra el menú de inicio
            System.out.println("INICIO DEL PROGRAMA");
            System.out.println("Seleccione la impelentación de Set que desea utilizar:");
            System.out.println("                .:Menu:.                       ");
            System.out.println("1. Hashset (el mas eficiente) ");
            System.out.println("2. TreeSet (ordena los elementos en una estructura de arbol)");
            System.out.println("3. LinkedHashSet (menor rendimiento)");
            //--------------------------------------------------------------------------------
            //Se ingresa la opcion escogida por el usuario
            opcion = ingreso.nextLine();
            
            /*Si la opcion ingresada no es correcta se muestra el mensaje de error 
              para que ingrese un número válido*/
            if (enteroAceptado (opcion,1,3)==false){
                System.out.println("¡OPCION INVALIDA, VUELVA A INTENTARLO!");
             
            }
            /*Si el valor es correcto, se convierte en un int para que pueda ya 
              utilizarse para la implementación según el factory*/
            else {
                implementacion = Integer.parseInt(opcion);
            }
        }
      
        System.out.println("Implementacion seleccionada correctamente");
        //SE CREA EL OBJETO FACTORY    
        FactoryImplementaciones _Factory = new    FactoryImplementaciones();
       
       
        //luego de que el usuario selecciona la implementacion de set que deseea 
        //se procede a ingresar los nombres de los programadores y a agregarlos a sus respectivos conjuntos
        
        //GENERAMOS LOS TRES CONJUNTOS GENERALES 
        Set<String> PJava = _Factory.ObtenerSet(implementacion);
        Set<String> PWeb = _Factory.ObtenerSet(implementacion);
        Set<String> PCel = _Factory.ObtenerSet(implementacion);
        
        System.out.println("conjuntos generados correctamente");
        //la variable proGenerico se encarga de almacenar los progamadores a medida que se van ingresando 
        //la variable cnt Ingresos se encarga de llevar la cuenta de programadores ingresados
        op = 'd';
        String ProGenerico; 
        int cntIngresos=1; //Llevará la cuenta del numero de programadores ingresados
        opcion= "algo";
        //Comenzamos a llenar los tres conjuntos segun la información proporcionada
        while (opcion.equals("2")== false)
        {
            //Se pide el nombre del programador
            System.out.println("Ingrese el nombre del programador No."+cntIngresos+" ");
            ProGenerico = ingreso.nextLine(); //Se guarda el nombre
            System.out.println("----------Hablidades del programador:------------- ");
            selector = "mayor que dos";
            /*Mientras el numero ingresado se encuentre entre 1 y 2 se procederá a 
             pedir datos para clasificacion*/
            while (enteroAceptado (selector,1,2)== false)
            {
                //Pregunta si sabe programar en java
                System.out.println("a) ¿Puede programar en Java?");
                System.out.println("1. SI");
                System.out.println("2. No");
                selector = ingreso.nextLine(); //Se almacena valor de opcion
            }
            //Si programa en java
            if (selector.equals("1"))
            {
                // en caso de que sepa programar en java se agrega a la lista PJAva
                PJava.add(ProGenerico);
                njava++; //Se suma 1 cada vez que se encuentre un programador de java
            }
            selector = "mayor que dos";
            //Para programadores web
            while (enteroAceptado (selector,1,2)== false)
            {
                //Se muestran opciones 
                System.out.println("a) ¿Puede programar en WEB?");
                System.out.println("1. SI");
                System.out.println("2. No");
                selector = ingreso.nextLine();
            }
            //Si es programador web
            if (selector.equals("1")){
                // en caso de que sepa programar en ambiente web 
                PWeb.add(ProGenerico);
                nweb++; //Se aumenta 1 el numero de programadores web
            }
             //--------------------------------------------------------------------------------
            selector = "mayor que dos";
            //Para programador en celulares
            /*Mientras el numero ingresado sea 1 o 2*/
            while (enteroAceptado (selector,1,2)== false)
            {
                System.out.println("a) ¿Puede programar Para Celulares?");
                System.out.println("1. SI");
                System.out.println("2. No");
                selector = ingreso.nextLine();
            }
            //Si es programador para celulares, se agregar a lista
            if (selector.equals("1")){
                // en caso de que sepa programar para celulares
                PCel.add(ProGenerico); //Se añade elemento a la coleccion de programadores p/ cel
                ncel++; //Se suma 1 al numero de programadores para celulares
            }
        
   
            //preguntar al usuario si se desean agregar mas programadores 
            System.out.println(" ");
        
            opcion = "mayor que dos";
             //Mientras que el valor aceptado sea 1 o 2
            while (enteroAceptado (opcion,1,2)== false)
            {
                //Pregunta si se desea agregar más programadores
                System.out.println("¿Desea agregar otro programador? S/N");
                //Opciones
                System.out.println("1. SI");
                System.out.println("2. No");
                opcion = ingreso.nextLine(); //Se almacena valor de opcion escogida
            }
      
            
        
            cntIngresos++; //Se suma 1 a la cantidad de ingresos totales
        
        }
        
        
        //Se imprimen las respuestas a las preguntas
        System.out.println("|---------------------------------------|");
        System.out.println("|RESPUESTAS A LAS PREGUNTAS PLANTEADAS: |");
        System.out.println("|---------------------------------------|");
        //EN ESTA PARTE SE GENERA EL CODIGO PARA RESPONDER LAS PREGUNTAS
        //Pregunta No. 1: genera la intersección de los 3 y mostrarla en pantalla
        Set<String> interseccion = new HashSet<String>(PJava); //set que almacenará la interseccion entre java, web y celulares
        interseccion.retainAll(PWeb);
        interseccion.retainAll(PCel);
        System.out.println("1. Desarrolladores con experiencia en Java, web y celulares.");
        
        Iterator _Iter = interseccion.iterator(); 
        //Mientras haya un iterador siguiente, se imprimirá el nombre de los desarrolladores
        while(_Iter.hasNext()){
            System.out.println(_Iter.next()); 
        }
        
        
        System.out.println("----------------------------------------------------------------------");
        Set<String> diferencia = new HashSet<String>(PJava); //set que almacenará a los desarrolladores de java pero no en web
        diferencia.removeAll(PWeb); //Se quitan del set los que se encuentren también de experiencia en web
        
        System.out.println("2. Desarrolladores con experiencia en Java pero que no tengan experiencia en web.");
        
        Iterator _Iter2 = diferencia.iterator();
        //Mientras haya otro iterador se imprimirá cada uno de ellos
        while(_Iter2.hasNext()){
            System.out.println(_Iter2.next()); 
        }
        
        System.out.println("----------------------------------------------------------------------");
        Set<String> ptres = new HashSet<String>(PWeb); //set que contiene a los desarrolladores web
        ptres.retainAll(PCel); //Se almacenan  los que tambien son desarrolladores para celulares
        ptres.removeAll(PJava); //Se eliminan los desarrolladores en java
        
        System.out.println("3.Desarrolladores con experiencia en Web y Celulares ");
        System.out.println("(intersección de Web y Celuares), pero que no tengan experiencia en java.");
        
        Iterator _Iter3 = ptres.iterator();
        //Mientras haya otro iterador, se imprimirá cada uno de ellos
        while(_Iter3.hasNext()){
            System.out.println(_Iter3.next()); 
        }
        
 
        System.out.println("----------------------------------------------------------------------");
        Set<String> pcuatro = new HashSet<String>(PWeb); //set que contiene a los desarrolladores web
        pcuatro.addAll(PCel); //Se añaden los desarrolladores para celulares
        pcuatro.removeAll(PJava); //Se eliminan los deasarrolladores de java
        System.out.println("4.Desarrolladores con experiencia en Web o Celulares (unión de Web y Celuares), pero que no tengan experiencia en java. ");
        Iterator _Iter4 = pcuatro.iterator();
        //Mientras haya otro iterador, se imprimirá cada uno de ellos
        while(_Iter4.hasNext()){
            System.out.println(_Iter4.next()); 
        }
        
        
         System.out.println("----------------------------------------------------------------------");
        System.out.println("5.¿ es el conjunto de desarrolladores Java  un subconjunto de Desarrolladores Web? ");
        //Si en el conjunto de desarrolladores web se encuentran todos los desarroladores de java es un subconjunto
        if (PWeb.containsAll(PJava)){
            System.out.println("SI, Los desarolladores Java son subconjunto de desarolladores Web");
        
        }
        //Al no contener a todos los desarrolladores de java se imprime que no es un subconjunto
        else{
            System.out.println("NO, Los desarolladores Java no son subconjunto de desarolladores Web");
        
        }
        
        //Para el set que contiene el mayor numero de desarrolladores
        List<String> list = new ArrayList<String>(); //Se crea una lista que contendrá al mayor numero de desarrolladores
        System.out.println("----------------------------------------------------------------------");
        System.out.println("6. ¿Cuál es el conjunto que tiene más desarolladores ? ");
        //Si los desarrolladores java son más
        if ((njava>nweb)&&(njava > ncel)){
            //Se imprime mensaje
            System.out.println("El conjunto más grande es el de desarolladores java");
            _Iter = PJava.iterator();
            //Mientras haya un iterador siguiente, se imprimiran los nombres de los desarrolladores de java
            while(_Iter.hasNext()){
                System.out.println(_Iter.next()); 
            }
            
            //Se ordena de orma ascendente dicha lista
             System.out.println("----------------------------------------------------------------------");
             System.out.println("7. Ordenado de forma ascendente: ");
                System.out.println("\n lista en orden ascendente");
                Set<String> orden = new TreeSet<String>(PJava); //Para ordenarlos, lo mas adecuado es utilizar TreeSet
                Iterator _Iterador = orden.iterator();
                //Mientras haya un iterador siguiente, se añadira a la lista
                while(_Iterador.hasNext()){
                        list.add((String)_Iterador.next());
                    }
                ListIterator iter = list.listIterator(list.size());
                while (iter.hasPrevious())
                    System.out.println(iter.previous());
        }
        
        //Si desarrolladores web son más
        if ((nweb>njava)&&(nweb > ncel)){
             System.out.println("El conjunto más grande es el de desarolladores Web");
            _Iter = PWeb.iterator();
            //si hay un interador siguiente, se imprimirán hasta que el siguiente sea nulo
            while(_Iter.hasNext()){
                System.out.println(_Iter.next()); 
            }
            
            //Al ordenarlos ascendentemente
             System.out.println("----------------------------------------------------------------------");
             System.out.println("7. Ordenado de forma ascendente: ");
             System.out.println("\n lista en orden ascendente");
                Set<String> orden1 = new TreeSet<String>(PWeb); //TreeSet que los ordena
                Iterator _Iterador = orden1.iterator();
                //Recorre, hasta el ultimo iterados
                while(_Iterador.hasNext()){
                        list.add((String)_Iterador.next());
                    }
                ListIterator iter = list.listIterator(list.size());
                while (iter.hasPrevious())
                    System.out.println(iter.previous());
        
        }
        //Si desarrolladores de celulares son más
        if ((ncel>njava)&&(ncel > nweb)){
             System.out.println("El conjunto más grande es el de desarolladores para celulares");
            _Iter = PCel.iterator();
            //Mientras haya un iterador siguiente, se imprimiran nombres de desarrolladores
            while(_Iter.hasNext()){
                System.out.println(_Iter.next()); 
            }
            //Para orden ascendente
             System.out.println("----------------------------------------------------------------------");
             System.out.println("7. Ordenado de forma ascendente: ");
             System.out.println("\n lista en orden ascendente");
                Set<String> orden2 = new TreeSet<String>(PCel); //TreeSet para que los ordene
                Iterator _Iterador = orden2.iterator();
                //Se añade a la lista mientras haya un iterador siguiente distinto de null
                while(_Iterador.hasNext()){
                        list.add((String)_Iterador.next());
                    }
                ListIterator iter = list.listIterator(list.size());
                //mientras haya un iterador anterior se imprimen los nombres de los desarrolladores
                while (iter.hasPrevious())
                    System.out.println(iter.previous());
        
        }
        //Si la cantidad de elementos en los 3 conuntos es el mismo se muestra mensaje
        if ((ncel== njava)&&(ncel == nweb)){
            System.out.println("Los tres conjuntos tienen la misma cantidad de elementos");
        }        
                
   
        
    }



//METODO DE PROGRAMACION DEFENSIVA
static boolean enteroAceptado (String analizar, int min, int max){
        int caja;
	boolean retorno;
	retorno = false; 
		//este metodo nos ayuda a verificar si el valor ingresado esta en el 
		//rango que deseamos
		
		try{	
            caja = Integer.parseInt(analizar);
				if ((Integer.parseInt(analizar) > (min-1))&&(Integer.parseInt(analizar) < (max+1))) {
					retorno = true; }
				
				//else{
					//System.out.println("ERROR: no se aceptan numeros negativos.");
				}
				
					
            catch(NumberFormatException loquequeramos){
                //System.out.println("ERROR: lo que ingreso no es un numero.");
				retorno = false; 
                }
		return retorno; 
	}


}
